/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package controladores;

import controladores.exceptions.IllegalOrphanException;
import controladores.exceptions.NonexistentEntityException;
import controladores.exceptions.PreexistingEntityException;
import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import modelo.Empleado;
import modelo.Cliente;
import modelo.Itemventa;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import modelo.Pagocliente;
import modelo.Venta;

/**
 *
 * @author usuario
 */
public class VentaJpaController implements Serializable {

    public VentaJpaController(EntityManagerFactory emf) {
        this.emf = emf;
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Venta venta) throws PreexistingEntityException, Exception {
        if (venta.getItemventaCollection() == null) {
            venta.setItemventaCollection(new ArrayList<Itemventa>());
        }
        if (venta.getPagoclienteCollection() == null) {
            venta.setPagoclienteCollection(new ArrayList<Pagocliente>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Empleado idempleado = venta.getIdempleado();
            if (idempleado != null) {
                idempleado = em.getReference(idempleado.getClass(), idempleado.getIdempleado());
                venta.setIdempleado(idempleado);
            }
            Cliente idcliente = venta.getIdcliente();
            if (idcliente != null) {
                idcliente = em.getReference(idcliente.getClass(), idcliente.getIdcliente());
                venta.setIdcliente(idcliente);
            }
            Collection<Itemventa> attachedItemventaCollection = new ArrayList<Itemventa>();
            for (Itemventa itemventaCollectionItemventaToAttach : venta.getItemventaCollection()) {
                itemventaCollectionItemventaToAttach = em.getReference(itemventaCollectionItemventaToAttach.getClass(), itemventaCollectionItemventaToAttach.getItemventaPK());
                attachedItemventaCollection.add(itemventaCollectionItemventaToAttach);
            }
            venta.setItemventaCollection(attachedItemventaCollection);
            Collection<Pagocliente> attachedPagoclienteCollection = new ArrayList<Pagocliente>();
            for (Pagocliente pagoclienteCollectionPagoclienteToAttach : venta.getPagoclienteCollection()) {
                pagoclienteCollectionPagoclienteToAttach = em.getReference(pagoclienteCollectionPagoclienteToAttach.getClass(), pagoclienteCollectionPagoclienteToAttach.getPagoclientePK());
                attachedPagoclienteCollection.add(pagoclienteCollectionPagoclienteToAttach);
            }
            venta.setPagoclienteCollection(attachedPagoclienteCollection);
            em.persist(venta);
            if (idempleado != null) {
                idempleado.getVentaCollection().add(venta);
                idempleado = em.merge(idempleado);
            }
            if (idcliente != null) {
                idcliente.getVentaCollection().add(venta);
                idcliente = em.merge(idcliente);
            }
            for (Itemventa itemventaCollectionItemventa : venta.getItemventaCollection()) {
                Venta oldVentaOfItemventaCollectionItemventa = itemventaCollectionItemventa.getVenta();
                itemventaCollectionItemventa.setVenta(venta);
                itemventaCollectionItemventa = em.merge(itemventaCollectionItemventa);
                if (oldVentaOfItemventaCollectionItemventa != null) {
                    oldVentaOfItemventaCollectionItemventa.getItemventaCollection().remove(itemventaCollectionItemventa);
                    oldVentaOfItemventaCollectionItemventa = em.merge(oldVentaOfItemventaCollectionItemventa);
                }
            }
            for (Pagocliente pagoclienteCollectionPagocliente : venta.getPagoclienteCollection()) {
                Venta oldVentaOfPagoclienteCollectionPagocliente = pagoclienteCollectionPagocliente.getVenta();
                pagoclienteCollectionPagocliente.setVenta(venta);
                pagoclienteCollectionPagocliente = em.merge(pagoclienteCollectionPagocliente);
                if (oldVentaOfPagoclienteCollectionPagocliente != null) {
                    oldVentaOfPagoclienteCollectionPagocliente.getPagoclienteCollection().remove(pagoclienteCollectionPagocliente);
                    oldVentaOfPagoclienteCollectionPagocliente = em.merge(oldVentaOfPagoclienteCollectionPagocliente);
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findVenta(venta.getIdventa()) != null) {
                throw new PreexistingEntityException("Venta " + venta + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Venta venta) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Venta persistentVenta = em.find(Venta.class, venta.getIdventa());
            Empleado idempleadoOld = persistentVenta.getIdempleado();
            Empleado idempleadoNew = venta.getIdempleado();
            Cliente idclienteOld = persistentVenta.getIdcliente();
            Cliente idclienteNew = venta.getIdcliente();
            Collection<Itemventa> itemventaCollectionOld = persistentVenta.getItemventaCollection();
            Collection<Itemventa> itemventaCollectionNew = venta.getItemventaCollection();
            Collection<Pagocliente> pagoclienteCollectionOld = persistentVenta.getPagoclienteCollection();
            Collection<Pagocliente> pagoclienteCollectionNew = venta.getPagoclienteCollection();
            List<String> illegalOrphanMessages = null;
            for (Itemventa itemventaCollectionOldItemventa : itemventaCollectionOld) {
                if (!itemventaCollectionNew.contains(itemventaCollectionOldItemventa)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Itemventa " + itemventaCollectionOldItemventa + " since its venta field is not nullable.");
                }
            }
            for (Pagocliente pagoclienteCollectionOldPagocliente : pagoclienteCollectionOld) {
                if (!pagoclienteCollectionNew.contains(pagoclienteCollectionOldPagocliente)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Pagocliente " + pagoclienteCollectionOldPagocliente + " since its venta field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (idempleadoNew != null) {
                idempleadoNew = em.getReference(idempleadoNew.getClass(), idempleadoNew.getIdempleado());
                venta.setIdempleado(idempleadoNew);
            }
            if (idclienteNew != null) {
                idclienteNew = em.getReference(idclienteNew.getClass(), idclienteNew.getIdcliente());
                venta.setIdcliente(idclienteNew);
            }
            Collection<Itemventa> attachedItemventaCollectionNew = new ArrayList<Itemventa>();
            for (Itemventa itemventaCollectionNewItemventaToAttach : itemventaCollectionNew) {
                itemventaCollectionNewItemventaToAttach = em.getReference(itemventaCollectionNewItemventaToAttach.getClass(), itemventaCollectionNewItemventaToAttach.getItemventaPK());
                attachedItemventaCollectionNew.add(itemventaCollectionNewItemventaToAttach);
            }
            itemventaCollectionNew = attachedItemventaCollectionNew;
            venta.setItemventaCollection(itemventaCollectionNew);
            Collection<Pagocliente> attachedPagoclienteCollectionNew = new ArrayList<Pagocliente>();
            for (Pagocliente pagoclienteCollectionNewPagoclienteToAttach : pagoclienteCollectionNew) {
                pagoclienteCollectionNewPagoclienteToAttach = em.getReference(pagoclienteCollectionNewPagoclienteToAttach.getClass(), pagoclienteCollectionNewPagoclienteToAttach.getPagoclientePK());
                attachedPagoclienteCollectionNew.add(pagoclienteCollectionNewPagoclienteToAttach);
            }
            pagoclienteCollectionNew = attachedPagoclienteCollectionNew;
            venta.setPagoclienteCollection(pagoclienteCollectionNew);
            venta = em.merge(venta);
            if (idempleadoOld != null && !idempleadoOld.equals(idempleadoNew)) {
                idempleadoOld.getVentaCollection().remove(venta);
                idempleadoOld = em.merge(idempleadoOld);
            }
            if (idempleadoNew != null && !idempleadoNew.equals(idempleadoOld)) {
                idempleadoNew.getVentaCollection().add(venta);
                idempleadoNew = em.merge(idempleadoNew);
            }
            if (idclienteOld != null && !idclienteOld.equals(idclienteNew)) {
                idclienteOld.getVentaCollection().remove(venta);
                idclienteOld = em.merge(idclienteOld);
            }
            if (idclienteNew != null && !idclienteNew.equals(idclienteOld)) {
                idclienteNew.getVentaCollection().add(venta);
                idclienteNew = em.merge(idclienteNew);
            }
            for (Itemventa itemventaCollectionNewItemventa : itemventaCollectionNew) {
                if (!itemventaCollectionOld.contains(itemventaCollectionNewItemventa)) {
                    Venta oldVentaOfItemventaCollectionNewItemventa = itemventaCollectionNewItemventa.getVenta();
                    itemventaCollectionNewItemventa.setVenta(venta);
                    itemventaCollectionNewItemventa = em.merge(itemventaCollectionNewItemventa);
                    if (oldVentaOfItemventaCollectionNewItemventa != null && !oldVentaOfItemventaCollectionNewItemventa.equals(venta)) {
                        oldVentaOfItemventaCollectionNewItemventa.getItemventaCollection().remove(itemventaCollectionNewItemventa);
                        oldVentaOfItemventaCollectionNewItemventa = em.merge(oldVentaOfItemventaCollectionNewItemventa);
                    }
                }
            }
            for (Pagocliente pagoclienteCollectionNewPagocliente : pagoclienteCollectionNew) {
                if (!pagoclienteCollectionOld.contains(pagoclienteCollectionNewPagocliente)) {
                    Venta oldVentaOfPagoclienteCollectionNewPagocliente = pagoclienteCollectionNewPagocliente.getVenta();
                    pagoclienteCollectionNewPagocliente.setVenta(venta);
                    pagoclienteCollectionNewPagocliente = em.merge(pagoclienteCollectionNewPagocliente);
                    if (oldVentaOfPagoclienteCollectionNewPagocliente != null && !oldVentaOfPagoclienteCollectionNewPagocliente.equals(venta)) {
                        oldVentaOfPagoclienteCollectionNewPagocliente.getPagoclienteCollection().remove(pagoclienteCollectionNewPagocliente);
                        oldVentaOfPagoclienteCollectionNewPagocliente = em.merge(oldVentaOfPagoclienteCollectionNewPagocliente);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                String id = venta.getIdventa();
                if (findVenta(id) == null) {
                    throw new NonexistentEntityException("The venta with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(String id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Venta venta;
            try {
                venta = em.getReference(Venta.class, id);
                venta.getIdventa();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The venta with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            Collection<Itemventa> itemventaCollectionOrphanCheck = venta.getItemventaCollection();
            for (Itemventa itemventaCollectionOrphanCheckItemventa : itemventaCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Venta (" + venta + ") cannot be destroyed since the Itemventa " + itemventaCollectionOrphanCheckItemventa + " in its itemventaCollection field has a non-nullable venta field.");
            }
            Collection<Pagocliente> pagoclienteCollectionOrphanCheck = venta.getPagoclienteCollection();
            for (Pagocliente pagoclienteCollectionOrphanCheckPagocliente : pagoclienteCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Venta (" + venta + ") cannot be destroyed since the Pagocliente " + pagoclienteCollectionOrphanCheckPagocliente + " in its pagoclienteCollection field has a non-nullable venta field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            Empleado idempleado = venta.getIdempleado();
            if (idempleado != null) {
                idempleado.getVentaCollection().remove(venta);
                idempleado = em.merge(idempleado);
            }
            Cliente idcliente = venta.getIdcliente();
            if (idcliente != null) {
                idcliente.getVentaCollection().remove(venta);
                idcliente = em.merge(idcliente);
            }
            em.remove(venta);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Venta> findVentaEntities() {
        return findVentaEntities(true, -1, -1);
    }

    public List<Venta> findVentaEntities(int maxResults, int firstResult) {
        return findVentaEntities(false, maxResults, firstResult);
    }

    private List<Venta> findVentaEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Venta.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Venta findVenta(String id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Venta.class, id);
        } finally {
            em.close();
        }
    }

    public int getVentaCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Venta> rt = cq.from(Venta.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
